(function (modules) {
  // 缓存已经加载过的模块
  var installedModules = {};

  // 下面的方法是webpack自定义的，核心作用是返回模块的 exports
  function __webpack_require__(moduleId) {
    // 先从缓存中拿 exports
    if (installedModules[moduleId]) {
      return installedModules[moduleId].exports;
    }
    // 创建一个新的模块并且缓存
    var module = (installedModules[moduleId] = {
      i: moduleId,
      l: false, // 是否加载 loaded
      exports: {},
    });

    // 执行 模块定义 的值
    // 第一个参数是用来改变this
    // 第二个参数吧当前模块传过去，最后模块定义导出的内容挂载到了 module.exports 身上
    // 第三个参数吧老的 module.exports 传给了模块定义 做参数使用
    // 第三个参数是让 模块定义内部有引入的时候可以做递归的引入
    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

    // 表示当前模块被加载了
    module.l = true;

    // 返回了 当前模块的 exports
    return module.exports;
  }

  // expose the modules object (__webpack_modules__)
  __webpack_require__.m = modules;

  // expose the module cache
  __webpack_require__.c = installedModules;

  // define getter function for harmony exports
  __webpack_require__.d = function (exports, name, getter) {
    if (!__webpack_require__.o(exports, name)) {
      Object.defineProperty(exports, name, { enumerable: true, get: getter });
    }
  };

  // define __esModule on exports
  __webpack_require__.r = function (exports) {
    if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
      Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
    }
    Object.defineProperty(exports, '__esModule', { value: true });
  };

  // create a fake namespace object
  // mode & 1: value is a module id, require it
  // mode & 2: merge all properties of value into the ns
  // mode & 4: return value when already ns object
  // mode & 8|1: behave like require
  __webpack_require__.t = function (value, mode) {
    if (mode & 1) value = __webpack_require__(value);
    if (mode & 8) return value;
    if (mode & 4 && typeof value === 'object' && value && value.__esModule) return value;
    var ns = Object.create(null);
    __webpack_require__.r(ns);
    Object.defineProperty(ns, 'default', { enumerable: true, value: value });
    if (mode & 2 && typeof value != 'string')
      for (var key in value)
        __webpack_require__.d(
          ns,
          key,
          function (key) {
            return value[key];
          }.bind(null, key)
        );
    return ns;
  };

  // getDefaultExport function for compatibility with non-harmony modules
  __webpack_require__.n = function (module) {
    var getter =
      module && module.__esModule
        ? function getDefault() {
            return module['default'];
          }
        : function getModuleExports() {
            return module;
          };
    __webpack_require__.d(getter, 'a', getter);
    return getter;
  };

  // Object.prototype.hasOwnProperty.call
  __webpack_require__.o = function (object, property) {
    return Object.prototype.hasOwnProperty.call(object, property);
  };

  // __webpack_public_path__
  __webpack_require__.p = '';

  // 开始加载第一个模块并且返回这个模块的 exports
  // exports 的内容就被暴露到 引入 built.js的环境中了
  return __webpack_require__((__webpack_require__.s = './src/index.js'));
})({
  './src/index.js': function (module, exports) {
    console.log('index.js内容');
    module.exports = '入口文件导出内容';
  },
});
/**
 * 01 webpack打包之后的内容就是一个自执行的函数，函数的参数传入一个对象
 * 02 为了方便，我们把这个参数称之为模块定义，它就是一个键值对
 * 03 键名就是当前 被加载模块的文件名称与某个目录的拼接
 * 04 键值就是一个函数，与nodejs中模块的加载有一些类似，会将加载的模块中的内容包裹在一个函数中
 * 05 这个函数在将来的某个时间点上会被执行，同时会接受一定的参数，通过使用这些参数就可以实现模块的加载操作
 *
 * 06 上述的代码就是将 模块定义 传递给了自执行的函数
 */
